package com.example.smart.order.controller;

import com.example.smart.order.entity.DiningTable;
import com.example.smart.order.entity.Dish;
import com.example.smart.order.entity.OrderInfo;
import com.example.smart.order.mapper.DishMapper;
import com.example.smart.order.mapper.DiningTableMapper;
import com.example.smart.order.mapper.OrderInfoMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.util.List;

/**
 * 订单信息控制器，处理与订单相关的HTTP请求
 */
@RestController
@Slf4j
@RequestMapping("/api/orderInfo")
public class OrderInfoController {

    @Autowired
    private OrderInfoMapper orderInfoMapper;

    @Autowired
    private DishMapper dishMapper;

    @Autowired
    private DiningTableMapper diningTableMapper; // 自动装配DiningTableMapper对象

    /**
     * 处理点餐请求
     *
     * @param tableId 餐桌ID
     * @param dishId  菜品ID
     * @return 处理结果，1表示成功，0表示失败
     */
    @PostMapping("/orderDish")
    public int orderDish(Long tableId, Long dishId) {
        log.debug("处理点餐请求，tableId: {}, dishId: {}", tableId, dishId);

        // 根据菜品ID查询菜品信息
        Dish dish = dishMapper.selectById(dishId);
        if (dish == null) {
            log.debug("菜品不存在，dishId: {}", dishId);
            return 0; // 菜品不存在
        }
        log.debug("查询到菜品信息: {}", dish);

        // 根据餐桌ID和菜品ID查询订单信息
        OrderInfo orderInfo = orderInfoMapper.selectByTableIdAndDishIdAndNotPaid(tableId, dishId);
        if (orderInfo == null) {
            // 创建新的订单信息
            orderInfo = new OrderInfo();
            orderInfo.setDiningTableId(tableId);
            orderInfo.setDishId(dishId);
            orderInfo.setDishName(dish.getName());
            orderInfo.setDishPrice(dish.getPrice());
            orderInfo.setDishQuantity(1);
            orderInfo.setCreatedAt(LocalDateTime.now());
            orderInfo.setIsPaid(0);
            orderInfoMapper.insert(orderInfo);
            log.debug("创建新订单: {}", orderInfo);
        } else {
            // 更新订单信息中的菜品数量
            orderInfo.setDishQuantity(orderInfo.getDishQuantity() + 1);
            orderInfo.setCreatedAt(LocalDateTime.now());
            orderInfoMapper.updateById(orderInfo);
            log.debug("更新订单数量，orderInfo: {}", orderInfo);
        }

        log.debug("订单处理成功，返回结果: 1");
        return 1; // 订单处理成功
    }

    /**
     * 处理餐厅结账请求
     *
     * @param tableId 餐桌ID
     * @return 处理结果，大于0表示成功，0表示失败
     */
    @PostMapping("/checkOut")
    public int checkOut(Long tableId) {
        log.debug("处理餐厅结账请求，tableId: {}", tableId);
        DiningTable diningTable = diningTableMapper.selectById(tableId); // 调用DiningTableMapper对象的“根据ID查询数据”方法
        if (diningTable == null) {
            log.debug("餐桌不存在，tableId: {}", tableId);
            return -1; // 餐桌不存在，直接返回-1
        }
        int result = orderInfoMapper.updateIsPaidByTableId(tableId, 1); // 调用OrderInfoMapper对象的“根据餐桌ID修改结账状态”方法
        log.debug("结账处理结果: {}", result);
        return result;
    }

    /**
     * 根据餐桌ID查询订单列表
     *
     * @param tableId 餐桌ID
     * @return 订单列表
     */
    @GetMapping("/listByTableId")
    public List<OrderInfo> listByTableId(Long tableId) {
        log.debug("处理查看订单列表请求，tableId: {}", tableId);
        // 调用Mapper接口根据餐桌ID查询未支付的订单列表
        List<OrderInfo> orderInfos = orderInfoMapper.selectByTableIdAndNotPaid(tableId);
        log.debug("查询到订单列表: {}", orderInfos);
        return orderInfos;
    }

    /**
     * 处理删除订单请求
     *
     * @param orderInfoId 订单ID
     * @return 处理结果，大于0表示成功，0表示失败
     */
    @PostMapping("/delete")
    public int delete(Long orderInfoId) {
        log.debug("处理删除订单请求，orderInfoId: {}", orderInfoId);

        // 根据ID查询订单数据
        OrderInfo orderInfo = orderInfoMapper.selectById(orderInfoId);
        if (orderInfo == null) {
            log.debug("订单不存在，orderInfoId: {}", orderInfoId);
            return -1; // 订单不存在
        }
        log.debug("查询到订单信息: {}", orderInfo);

        // 根据ID删除订单数据
        int result = orderInfoMapper.deleteById(orderInfoId);
        log.debug("删除订单结果: {}", result);

        return result;
    }
}